home *** CD-ROM | disk | FTP | other *** search
/ NeXT Education Software Sampler 1992 Fall / NeXT Education Software Sampler 1992 Fall.iso / Programming / Source / WAIS / ir / cutil.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-02-02  |  14.4 KB  |  632 lines
  1. /* Wide AREA INFORMATION SERVER SOFTWARE    
  2.    No guarantees or restrictions.  See the readme file for the full standard
  3.    disclaimer.  
  4.   
  5.    3.26.90    Harry Morris, morris@think.com
  6.    4.11.90  HWM - generalized conditional includes (see c-dialect.h)
  7.    7/19/91  speed up substrcmp by ses@ccgr.technion.ac.il (Simon E Spero)
  8. */
  9.  
  10. #define _C_C_util_
  11.  
  12. #include "cutil.h"
  13. #include "panic.h"
  14.  
  15. #include <string.h>
  16.  
  17. #ifdef ANSI_LIKE
  18. #include <stdarg.h>
  19. #else /* ndef ANSI_LIKE */
  20. #include <varargs.h>
  21. #endif /* ndef ANSI_LIKE */
  22.  
  23. #ifdef M_XENIX /* perhaps this should be in ustubs.h */
  24. #include <malloc.h>
  25. char* calloc();
  26. #endif /* def M_XENIX */
  27.  
  28. /*----------------------------------------------------------------------*/
  29.  
  30. /*#define MEMORY_ACCOUNTING*/
  31.  
  32. #ifdef MEMORY_ACCOUNTING
  33. #undef s_checkPtr
  34. #define s_checkPtr(ptr) fs_checkPtr(ptr)
  35. static FILE* memRecord = NULL;
  36. static void prepMemAcct _AP((void));
  37. static void 
  38. prepMemAcct()
  39. {
  40.   if (memRecord == NULL)
  41.     memRecord = s_fopen("MemoryAccounting","w");
  42. }
  43. static void flushMemAcct _AP((void));
  44. static void 
  45. flushMemAcct()
  46. {
  47.   fflush(memRecord);
  48. }
  49. #define tickles 0
  50. static char*     badPtr    = (char*)-1;
  51. static size_t    badSize    = -1;
  52. #endif /* def MEMORY_ACCOUNTING */
  53.  
  54. /*----------------------------------------------------------------------*/
  55.  
  56. void
  57. fs_checkPtr(ptr)
  58. void* ptr;
  59. /* If the ptr is NULL, give an error */
  60. { 
  61. #ifdef MEMORY_ACCOUNTING
  62. static char** ptrs = NULL;
  63. long i;
  64. static Boolean  doneSetup = false;
  65. if (doneSetup == false)
  66. {
  67. #ifdef THINK_C
  68. Debugger();
  69. #endif /* def THINK_C */
  70. doneSetup = true;
  71. }
  72. #endif /* def MEMORY_ACCOUNTING */
  73.  
  74.   if (ptr == NULL)
  75.     panic("checkPtr found a NULL pointer");
  76.  
  77. #ifdef MEMORY_ACCOUNTING
  78. /* look for specific ptr (useful when tracking un-freed memory) */
  79. if (ptr == badPtr) warn("checking found bad ptr"); 
  80. /* tickle a memory bug */
  81. if (ptrs == NULL && tickles > 0)
  82.   ptrs = (char**)malloc((size_t)tickles * sizeof(char*));
  83. for (i = 0; i < tickles; i++)
  84. { ptrs[i] = malloc((size_t)5);
  85. }
  86. for (i = 0; i < tickles; i++)
  87. { free(ptrs[i]);
  88. }
  89. #endif /* def MEMORY_ACCOUNTING */
  90.  
  91. }
  92.  
  93. /*----------------------------------------------------------------------*/
  94.  
  95. void*
  96. fs_malloc(size)
  97. size_t size;
  98. /* does safety checks and optional accounting */
  99. { 
  100.   register void* ptr = NULL;
  101.  
  102. #ifdef THINK_C
  103.   ptr = (void*)NewPtr((long)size);
  104.   s_checkPtr(ptr);
  105.   memset(ptr,0,(size_t)size);    /* zero it */
  106. #else  
  107.   ptr = (void*)calloc((size_t)size,(size_t)1);
  108.   s_checkPtr(ptr);
  109. #endif
  110.   
  111. #ifdef MEMORY_ACCOUNTING
  112.   /* look for specific size (useful when tracking un-freed memory) */
  113.   if (size == badSize)
  114.     warn("bad size in malloc");
  115.   
  116.   prepMemAcct();
  117.   fprintf(memRecord,"malloced %lu bytes at %lu\n",size,ptr);
  118.   flushMemAcct();
  119. #endif
  120.  
  121.   return(ptr);
  122. }
  123.  
  124. /*----------------------------------------------------------------------*/
  125.  
  126. void*
  127. fs_realloc(ptr,size)
  128. void* ptr;
  129. size_t size;
  130. /* does safety checks and optional accounting 
  131.    note - we don't know how big ptr's memory is, so we can't ensure
  132.    that any new memory allocated is NULLed!
  133.  */
  134. { 
  135.   register void* nptr = NULL;
  136.   
  137.   if (ptr == NULL)        /* this is really a malloc */
  138.     return(s_malloc(size));
  139.     
  140. #ifdef THINK_C
  141.   nptr = NewPtr(size);        /* need to make a copy */ 
  142.   s_checkPtr(nptr);
  143.   BlockMove(ptr,nptr,size);    /* move the old contents into it */
  144.   DisposPtr(ptr);            /* get rid of the old ones */
  145. #else
  146.   nptr = (void*)realloc(ptr,size);
  147.   s_checkPtr(ptr);
  148. #endif  
  149.    
  150. #ifdef MEMORY_ACCOUNTING
  151.   /* look for specific size (useful when tracking un-freed memory) */
  152.   if (size == badSize) 
  153.     warn("bad size in realloc");
  154.   
  155.   prepMemAcct();
  156.   fprintf(memRecord,"realloced %lu bytes at %lu from %lu\n",size,nptr,ptr);
  157.   flushMemAcct();
  158. #endif
  159.  
  160.   return(nptr);
  161. }
  162.  
  163. /*----------------------------------------------------------------------*/
  164.  
  165. void
  166. fs_free(ptr)
  167. void* ptr;
  168. /* does safety checks and optional accounting */
  169. {
  170. #ifdef MEMORY_ACCOUNTING
  171.   prepMemAcct();
  172.   /* note that the sizeof a pointer is always 4.  If only we could find out
  173.      how much space that pointer was pointing to.  Oh well, this is a place
  174.      holder for now
  175.    */
  176.   fprintf(memRecord,"freed %lu bytes at %lu\n",(size_t)sizeof(ptr),ptr);
  177.   flushMemAcct();
  178.  
  179.   /* look for specific ptr (useful when tracking un-freed memory) */
  180.   if (ptr == badPtr) warn("bad ptr in free");
  181. #endif
  182.  
  183.   if (ptr != NULL)        /* some non-ansi compilers/os's cant handle freeing null */
  184.     {                /* if we knew the size of this block of memory, we could clear it - oh well */
  185. #ifdef THINK_C
  186.       DisposPtr(ptr);
  187. #else
  188.       free(ptr);
  189. #endif
  190.     }
  191. }
  192.  
  193. /*----------------------------------------------------------------------*/
  194.  
  195. char*
  196. s_strdup(s)
  197. char* s;
  198.  
  199. /* return a copy of s.  This is identical to the standard library routine
  200.    strdup(), except that it is safe.  If s == NULL or malloc fails, 
  201.    appropriate action is taken.
  202.  */
  203. {
  204.   unsigned long len;
  205.   char* copy = NULL;
  206.   
  207.   if (s == NULL)        /* saftey check to postpone stupid errors */
  208.     return(NULL);
  209.     
  210.   len = strlen(s);        /* length of string - terminator */
  211.   copy = (char*)s_malloc((size_t)(sizeof(char)*(len + 1)));
  212.   strncpy(copy,s,len + 1);
  213.   return(copy);
  214. }
  215.  
  216. /*----------------------------------------------------------------------*/
  217.  
  218. char*
  219. fs_strncat(dst,src,maxToAdd,maxTotal)
  220. char* dst;
  221.    char* src;
  222.    size_t maxToAdd;
  223.    size_t maxTotal;
  224.  
  225. /* like strncat, except the fourth argument limits the maximum total 
  226.    length of the resulting string
  227.  */
  228. {
  229.   size_t dstSize = strlen(dst);
  230.   size_t srcSize = strlen(src);
  231.   
  232.   if (dstSize + srcSize < maxTotal) /* use regular old strncat */
  233.     return(strncat(dst,src,maxToAdd));
  234.   else
  235.     { size_t truncateTo = maxTotal - dstSize - 1;
  236.       char   saveChar = src[truncateTo];
  237.       char*  result = NULL;
  238.       src[truncateTo] = '\0';
  239.       result = strncat(dst,src,maxToAdd);
  240.       src[truncateTo] = saveChar;
  241.       return(result);
  242.     }
  243. }
  244.  
  245. /*----------------------------------------------------------------------*/
  246.  
  247. typedef long (longfunc) _AP((long c));
  248.  
  249. char*
  250. strtokf(s1,isDelimiter)
  251. char* s1;
  252. longfunc *isDelimiter; /* really *isDelimiter() */
  253.  
  254. /* This function is exactly like strtok, except that instead of passing a 
  255.    delimiter string, you pass a function that decides if a character is 
  256.    a delimiter or not, returning IS_DELIMITER or NOT_DELIMITER respecively.
  257.    Note that passing a NULL delimiter function will cause the last delimiter
  258.    to be used.
  259.  */
  260. {
  261.   static char* searchStr = NULL;
  262.   static longfunc *delimiterFunc;
  263.   long i;
  264.   char* startTok = NULL;
  265.  
  266.   if (s1 != NULL)        /* passing s1 = NULL says use the last pos */
  267.     searchStr = s1;
  268.     
  269.   if (isDelimiter != NULL)
  270.     delimiterFunc = isDelimiter;
  271.    
  272.   if (searchStr == NULL || searchStr[0] == '\0')
  273.     return(NULL);        /* nothing left to search */
  274.     
  275.   if (delimiterFunc == NULL)
  276.     return(NULL);        /* no delimiter to search with */
  277.     
  278.   /* find the start of the next token */
  279.   for (i = 0; searchStr[i] != '\0'; i++)
  280.     { if ((*delimiterFunc)((long)searchStr[i]) == NOT_DELIMITER)
  281.     break;
  282.     }
  283.   
  284.   if (searchStr[i] == '\0') 
  285.     return(NULL);        /* read to end of search string */
  286.   else
  287.     startTok = searchStr + i;    /* remember the starting point for this token*/
  288.     
  289.   /* find the end of the next token */
  290.   for (; searchStr[i] != '\0'; i++)
  291.     { if ((*delimiterFunc)((long)searchStr[i]) == IS_DELIMITER)
  292.     break;
  293.     }
  294.    
  295.   /* if the end is a delimiter (and not just the end of the search string)
  296.      replace it with '\0', and put searchStr just beyond it, otherwise
  297.      put searchStr at the terminator. */
  298.   if (searchStr[i] != '\0')
  299.     { searchStr[i] = '\0';
  300.       searchStr = searchStr + i + 1;
  301.     }
  302.   else
  303.     searchStr = searchStr + i;
  304.    
  305.   return(startTok);
  306. }
  307.  
  308. /*----------------------------------------------------------------------*/
  309.  
  310. #ifdef ANSI_LIKE /* use ansi varargs */
  311.  
  312. long
  313. cprintf(print,format)
  314. boolean print;
  315. char* format;
  316. /* just like printf, but only prints if the first argument = 1 */
  317. {
  318.   va_list ap;            /* the variable arguments */
  319.   if (print == 1)
  320.     { long res;
  321.       va_start(ap,format);    /* init ap */
  322.       res = vprintf(format,ap);    /* print the contents */
  323.       va_end(ap);        /* free ap */
  324.       return(res);
  325.     }
  326.   else
  327.     return(0);
  328. }
  329.  
  330. #else /* use k&r varargs */
  331.  
  332. long
  333. cprintf(va_alist)
  334. va_dcl
  335. /* just like printf, but only prints if the first argument = 1 */
  336. {
  337.   va_list ap;            /* the variable arguments */
  338.   boolean print;
  339.   long res;
  340.  
  341.   va_start(ap);            /* init ap */
  342.  
  343.   print = va_arg(ap,boolean);    /* get the condition */
  344.  
  345.   if (print == 1)
  346.     { char* format = va_arg(ap,char*); /* get the format */
  347. #ifdef BSD /* some folks can't do vfprintf */
  348.       res = printf("%s",format); /* just print the first thing */
  349. #else
  350.       res = vprintf(format,ap);    /* print the contents */
  351. #endif
  352.     }
  353.   else
  354.     res = 0;
  355.  
  356.   va_end(ap);            /* free ap */
  357.  
  358.   return(res);
  359. }
  360.  
  361.   
  362. #endif
  363.  
  364. extern char* log_file_name;
  365. extern FILE* logfile;
  366.  
  367. /* waislog - a new and improved logging facility.
  368.    first two arguments are important, the rest is text.
  369.  
  370.    arg1: priority.  If priority > log_level (some global), output this
  371.    message
  372.  
  373.    arg2: message code.  This is the kind of message (search, retrieval, etc).
  374. */
  375.  
  376. #ifdef ANSI_LIKE /* use ansi varargs */
  377.  
  378. void
  379. waislog(priority, message, format)
  380. long priority;
  381. long message;
  382. char *format;
  383. /* just like printf, but prints to the logfile, with PID and time. */
  384. {
  385.   va_list ap;            /* the variable arguments */
  386.   static long line = 0;
  387.  
  388.   if(logfile == NULL && log_file_name != NULL)
  389.     logfile = fopen(log_file_name, "a");
  390.  
  391.   if(logfile) {
  392.     va_start(ap, format);
  393.  
  394.     fprintf(logfile, "%d: %d: %s: %d: ", getpid(), line++, printable_time(), message);
  395.  
  396.     vfprintf(logfile, format,ap);    /* print the contents */
  397.     fprintf(logfile, "\n");
  398.     fflush(logfile);
  399.     va_end(ap);            /* free ap */
  400.   }
  401.  
  402.   if(logfile != NULL && logfile != stderr) {
  403.     fclose(logfile);
  404.     logfile = NULL;
  405.   }
  406. }
  407.  
  408. #ifdef old
  409. void
  410. waislog(priority, message, format)
  411. long priority;
  412. long message;
  413. char *format;
  414. /* just like printf, but prints to the logfile, with PID and time. */
  415. {
  416.   va_list ap;            /* the variable arguments */
  417.   static long line = 0;
  418.  
  419.   if(logfile == NULL && log_file_name != NULL)
  420.     logfile = fopen(log_file_name, "a");
  421.  
  422.   if(logfile) {
  423.     va_start(ap, priority);
  424.     message = (long)va_arg(ap, long);
  425.  
  426.     fprintf(logfile, "%d: %d: %s: %d: ", getpid(), line++, printable_time(), message);
  427.  
  428.     format = (char*)va_arg(ap, char*);
  429.  
  430.     vfprintf(logfile, format,ap);    /* print the contents */
  431.     fprintf(logfile, "\n");
  432.     fflush(logfile);
  433.     va_end(ap);            /* free ap */
  434.   }
  435.  
  436.   if(logfile != NULL && logfile != stderr) {
  437.     fclose(logfile);
  438.     logfile = NULL;
  439.   }
  440. }
  441. #endif /*old*/
  442. #else /* use k&r varargs */
  443.  
  444. #ifndef BSD
  445. void
  446. waislog(va_alist)
  447. va_dcl
  448. /* just like printf, but prints to the logfile, with PID and time. */
  449. {
  450.   va_list ap;            /* the variable arguments */
  451.   char* format;
  452.   static long line = 0;
  453.   int priority, message;
  454.  
  455.   if(logfile == NULL && log_file_name != NULL)
  456.     logfile = fopen(log_file_name, "a");
  457.  
  458.   
  459.   if(logfile) {
  460.     va_start(ap);        /* init ap */
  461.  
  462.     priority = va_arg(ap, int);
  463.     message = va_arg(ap, int);
  464.  
  465.     fprintf(logfile, "%d: %d: %s: %d: ", getpid(), line++, printable_time(), message);
  466.  
  467.     format = va_arg(ap,char*);    /* get the format */
  468.  
  469.     vfprintf(logfile, format,ap); /* print the contents */
  470.     fprintf(logfile, "\n");
  471.     fflush(logfile);
  472.     va_end(ap);            /* free ap */
  473.   }
  474.  
  475.   if(logfile != NULL && logfile != stderr) {
  476.     fclose(logfile);
  477.     logfile = NULL;
  478.   }
  479. }
  480. #endif /* NOT BSD */
  481.  
  482. #endif /* ANSI_LIKE */
  483.   
  484. /*----------------------------------------------------------------------*/
  485.  
  486. void
  487. warn(message)
  488. char* message;
  489.  
  490. {
  491. #ifdef THINK_C
  492.   Debugger();
  493. #else
  494.   printf("%s\n<press return to continue>\n",message);
  495.   getchar();
  496. #endif
  497. }
  498.  
  499. /*----------------------------------------------------------------------*/
  500. boolean substrcmp(string1,string2)
  501. char *string1, *string2;
  502. {
  503.   /* compares the strings up until one of then ends.
  504.    * returns true if they are the same, false if not.
  505.    */
  506.   register char *a, *b;
  507.   
  508.   a = string1;
  509.   b = string2;
  510.   
  511.   while (*a && *b) 
  512.     if(*a++ != *b++) 
  513.       return false;
  514.   return true;
  515. }
  516.  
  517. /*----------------------------------------------------------------------*/
  518.  
  519. char *printable_time()
  520. { 
  521.   static char *string;
  522.   time_t tptr;
  523.   time(&tptr);
  524.   string = ctime(&tptr);
  525.   if(string){
  526.     if(string[strlen(string)-1] == '\n')
  527.       string[strlen(string)-1] = '\0';   
  528.     return(string+4);
  529.   }
  530.   else
  531.     return("Time Unknown");
  532. }
  533.  
  534. /*----------------------------------------------------------------------*/
  535.  
  536. char char_downcase(long_ch)
  537. unsigned long long_ch;
  538. {
  539.   unsigned char ch = long_ch & 0xFF; /* just want one byte */
  540.   /* when ansi is the way of the world, this can be tolower */
  541.   return (((ch >= 'A') && (ch <= 'Z')) ? (ch + 'a' -'A') : ch);
  542. }
  543.  
  544. char *string_downcase(word)
  545. char *word;
  546. {
  547.   long i = 0;
  548.   while(word[i] != '\0'){
  549.     word[i] = char_downcase((unsigned long)word[i]);
  550.     i++;
  551.   }
  552.   return(word);
  553. }
  554.  
  555. /*----------------------------------------------------------------------*/
  556.  
  557.  
  558. /* parsing arguments functions */
  559.  
  560. char *next_arg(argc,argv)
  561. int *argc;
  562. char ***argv;
  563.  
  564.      /* Returns NULL when it is out of arguments,
  565.         This side effects both argc and argv.  argc always contains the number
  566.     of arguments left.
  567.     The first returned is the command name. 
  568.     */
  569. {
  570.   if((*argc)-- > 0)
  571.     return(*((*argv)++));
  572.   else
  573.     return(NULL);
  574. }
  575.  
  576. /*----------------------------------------------------------------------*/
  577.  
  578. char *peek_arg(argc,argv)
  579. int *argc;
  580.     char ***argv;
  581.  
  582.      /* Returns the next argument without popping it.
  583.        Returns NULL when it is out of arguments.
  584.        */
  585. {
  586.   if((*argc) > 0)
  587.     return(**argv);
  588.   else
  589.     return(NULL);
  590. }
  591.  
  592. /*----------------------------------------------------------------------*/
  593.  
  594.  
  595. #ifdef THINK_C
  596. #include <EventMgr.h>
  597. #undef MAX_FILE_NAME_LEN 
  598. #ifdef WAIStation
  599. #include "CRetrievalApp.h"
  600. #endif /* def WAIStation */
  601. #endif /* def THINK_C */
  602.  
  603. void
  604. beFriendly()
  605. /* this routine is called during time intensive operations
  606.    on single processing machines (macs and DOS).  It gives
  607.    time to other processes
  608.  */
  609. { 
  610. #ifdef never
  611. #ifdef THINK_C
  612.    EventRecord      macEvent;    /* an event */
  613.  
  614.    static RgnHandle    mouseRgn = NULL; /* region for mouse moved events */
  615.    long                sleepTime;     /* max time between events */
  616.    
  617. #ifdef WAIStation
  618.    gApplication->FrobWaitCursor();
  619. #endif /* def WAIStation */
  620.    
  621.    if (mouseRgn == NULL)
  622.      mouseRgn = NewRgn(); /* do we need to set its value? */
  623.      
  624.    sleepTime = 5; /* arbitrary - a tech note recommends < 50 */
  625.    
  626.    WaitNextEvent(everyEvent,&macEvent,sleepTime,mouseRgn); 
  627. #endif /* def THINK_C */
  628. #endif
  629. }
  630.  
  631. /*----------------------------------------------------------------------*/
  632.